--- layout: default title: Gaussian process kernels description: Explore the Gaussian process kernels fitted by gradient descent. ---

This post will go more in-depth in the kernels fitted in our example fitting a Gaussian process to model atmospheric CO₂ concentrations . We will describe and visually explore each part of the kernel used in our fitted model, which is a combination of the exponentiated quadratic kernel, exponentiated sine squared kernel, and rational quadratic kernel. This post is part of series on Gaussian processes:

  1. Understanding Gaussian processes
  2. Fitting a Gaussian process kernel
  3. Gaussian process kernels (this)
In [1]:
In [2]:

Kernel function

A kernel (or covariance function) describes the covariance of the Gaussian process random variables. Together with the mean function the kernel completely defines a Gaussian process.

In the first post we introduced the concept of the kernel which defines a prior on the Gaussian process distribution. To summarize the kernel function $k(x, x')$ models the covariance between each pair in $x$. The kernel function together with the mean function $m(x)$ define the Gaussian process distribution:

$$y \sim \mathcal{GP}(m(x),k(x,x'))$$

Valid kernels

In order to be a valid kernel function the resulting kernel matrix $\Sigma = k(X, X)$ should be positive definite . Which implies that the matrix should be symmetric . Being positive definite also means that the kernel matrix is invertible .

The process of defining a new valid kernel from scratch it not always trivial. Typically pre-defined kernels are used to model a variety of processes. In what follows we will visually explore some of these pre-defined kernels that we used in our fitting example .

In [3]:

White noise kernel

The white noise kernel represents independent and identically distributed noise added to the Gaussian process distribution.

$$k(x, x) = \sigma^2 I_n$$

With:

  • $\sigma^2$ the variance of the noise.
  • $I_n$ the identity matrix.

This formula results in a covariance matrix with zeros everywhere except on the diagonal of the covariance matrix. This diagonal contains the variances of the individual random variables. All covariances between samples are zero because the noise is uncorrelated.

Samples from the white noise kernel together with a visual representation of the covariance matrix are plotted in the next figure.

In [4]:

Exponentiated quadratic kernel

The exponentiated quadratic kernel (also known as squared exponential kernel, Gaussian kernel or radial basis function kernel) is one of the most popular kernels used in Gaussian process modelling. It can be computed as:

$$k(x_a, x_b) = \sigma^2 \exp \left(-\frac{ \left\Vert x_a - x_b \right\Vert^2}{2\ell^2}\right)$$

With:

  • $\sigma^2$ the overall variance ($\sigma$ is also known as amplitude).
  • $\ell$ the lengthscale.

Using the exponentiated quadratic kernel will result in a smooth prior on functions sampled from the Gaussian process.

In [5]: 
def exponentiated_quadratic_tf(amplitude, length_scale):
    """Exponentiated quadratic TensorFlow operation."""
    amplitude_tf = tf.constant(amplitude, dtype=tf.float64)
    length_scale_tf = tf.constant(length_scale, dtype=tf.float64)
    kernel = psd_kernels.ExponentiatedQuadratic(
        amplitude=amplitude_tf, 
        length_scale=length_scale_tf)
    return kernel
                                  

def exponentiated_quadratic(xa, xb, amplitude, length_scale):
    """Evaluate exponentiated quadratic."""
    kernel = exponentiated_quadratic_tf(amplitude, length_scale)
    kernel_matrix = kernel.matrix(xa, xb)
    with tf.Session() as sess:
        return sess.run(kernel_matrix)

The exponentiated quadratic is vizualized in the next figures. The first figure shows the distance plot with respect to $0$: $k(0, x)$. Note that the similarity outputted by the kernel decreases exponentially towards $0$ the farther we move move away from the center, and that the similarity is maximum at the center $x_a = x_b$.

In [6]:

The following figure shows samples from the exponentiated quadratic kernel together with a visual representation of its covariance matrix.

Observe in the previous and following figure that increasing the lengthscale parameter $\ell$ increases the spread of the covariance. Increasing the amplitude parameter $\sigma$ increases the maximum value of the covariance.

In [7]:

Rational quadratic kernel

$$k(x_a, x_b) = \sigma^2 \left( 1 + \frac{ \left\Vert x_a - x_b \right\Vert^2}{2 \alpha \ell^2} \right)^{-\alpha}$$

With:

  • $\sigma^2$ the overall variance ($\sigma$ is also known as amplitude).
  • $\ell$ the lengthscale.
  • $\alpha$ the scale-mixture ($\alpha$ > 0).

Similar to the exponentiated quadratic the rational quadratic kernel will result in a somewhat smooth prior on functions sampled from the Gaussian process. The rational quadratic can be interpreted as an infinite sum of different exponentiated quadratic kernels with different lenghtscales with $\alpha$ determining the weighting between different lengthscales. When $\alpha \rightarrow \infty$ the rational quadratic kernel converges into the exponentiated quadratic kernel.

In [8]: 
def rational_quadratic_tf(length_scale, scale_mixture, amplitude):
    """Rational quadratic TensorFlow operation."""
    amplitude_tf = tf.constant(amplitude, dtype=tf.float64)
    length_scale_tf = tf.constant(length_scale, dtype=tf.float64)
    scale_mixture_tf = tf.constant(scale_mixture, dtype=tf.float64)
    kernel = psd_kernels.RationalQuadratic(
        amplitude=amplitude_tf,
        length_scale=length_scale_tf,
        scale_mixture_rate=scale_mixture_tf)
    return kernel


def rational_quadratic(xa, xb, length_scale, scale_mixture):
    """Evaluate rational quadratic."""
    kernel = rational_quadratic_tf(length_scale, scale_mixture, 1)
    kernel_matrix = kernel.matrix(xa, xb)
    with tf.Session() as sess:
        return sess.run(kernel_matrix)

The rational quadratic is vizualized in the next figures. The first figure shows the distance plot with respect to $0$: $k(0, x)$ with the amplitude $\sigma$ fixed to $0$.

Note that just like the exponentiated quadratic the similarity outputted by the kernel decreases towards $0$ the farther we move move away from the center, and that the similarity is maximum at the center $x_a = x_b$.

In [9]:

The following figure shows samples from the rational quadratic kernel together with a visual representation of its covariance matrix. The amplitude $\sigma$ is fixed to $0$ in all figures, changing the amplitude will have the same effect as changing the amplitude in the exponentiated quadratic.

Observe that in the previous and following figure that increasing the lengthscale parameter $\ell$ increases the overall spread of the covariance. Decreasing the scale-mixture $\alpha$ will allow for more minor local variations while still keeping the longer scale trends defined by the lengthscale parameter. Increasing the scale-mixture to a large value reduces the minor local variations.

In [10]:

Periodic kernel

$$k(x_a, x_b) = \sigma^2 \exp \left(-\frac{2}{\ell^2}\sin^2 \left( \pi \frac{\lvert x_a - x_b \rvert}{p}\right) \right)$$

With:

  • $\sigma^2$ the overall variance ($\sigma$ is also known as amplitude).
  • $\ell$ the lengthscale.
  • $p$ the period, which is the distance between repetitions.

The periodic kernel allows us to model periodic functions .

In [11]: 
def periodic_tf(length_scale, period):
    """Periodic kernel TensorFlow operation."""
    amplitude_tf = tf.constant(1, dtype=tf.float64)
    length_scale_tf = tf.constant(length_scale, dtype=tf.float64)
    period_tf = tf.constant(period, dtype=tf.float64)
    kernel = psd_kernels.ExpSinSquared(
        amplitude=amplitude_tf, 
        length_scale=length_scale_tf,
        period=period_tf)
    return kernel

def periodic(xa, xb, length_scale, period):
    """Evaluate periodic kernel."""
    kernel = periodic_tf(length_scale, period)
    kernel_matrix = kernel.matrix(xa, xb)
    with tf.Session() as sess:
        return sess.run(kernel_matrix)

The periodic kernel is vizualized in the next figures. The first two figures show the distance plot with respect to $0$: $k(0, x)$ with the amplitude $\sigma$ fixed to $0$ and different variations of the other parameters.

In [12]:

The following figure shows samples from the periodic kernel together with a visual representation of its covariance matrix. The amplitude $\sigma$ is fixed to $0$ in all figures.

Observe that in the previous and following figures that increasing the period $p$ increases the distance between the repetitions (increasing the wavelength). Increasing the lengthscale parameter $\ell$ decreases the local variations within a repetition in the same way that increasing the lengthscale in the exponentiated quadratic kernel decreases the variations over a longer range.

In [13]:

Combining kernels by multiplication

Kernels can be combined by multiplying them together. Multiplying kernels is an elementwise multiplication of their corresponding covariance matrices. This means that the covariances of the two multiplied kernels will only have a high value if both covariances have a high value. The multiply operation can thus be interpreted as an AND operation.

Local periodic kernel

The local periodic kernel is a multiplication of the periodic kernel with the exponentiated quadratic kernel to allow the periods to vary over longer distances. Note that the variance parameters $\sigma^2$ are combined into one.

$$k(x_a, x_b) = \sigma^2 \exp \left(-\frac{2}{\ell^2}\sin^2 \left( \pi \frac{\lvert x_a - x_b \rvert}{p}\right) \right) \exp \left(-\frac{ \left\Vert x_a - x_b \right\Vert^2}{2\ell^2}\right)$$

With:

  • $\sigma^2$ the overall variance ($\sigma$ is also known as amplitude).
  • $\ell_p$ lengthscale of the periodic function.
  • $p$ the period.
  • $\ell_{eq}$ the lengthscale of the exponentiated quadratic.
In [14]: 
def local_periodic_tf(periodic_length_scale, period, 
                      amplitude, local_length_scale):
    """Local periodic kernel TensorFlow operation."""
    periodic_length_scale_tf = tf.constant(
        periodic_length_scale, dtype=tf.float64)
    period_tf = tf.constant(period, dtype=tf.float64)
    amplitude_tf = tf.constant(amplitude, dtype=tf.float64)
    local_length_scale_tf = tf.constant(
        local_length_scale, dtype=tf.float64)
    kernel = (
        psd_kernels.ExpSinSquared(
            amplitude=amplitude_tf, 
            length_scale=periodic_length_scale_tf,
            period=period_tf) *
        psd_kernels.ExponentiatedQuadratic(
            length_scale=local_length_scale_tf))
    return kernel


def local_periodic(xa, xb, periodic_length_scale, period, 
                   amplitude, local_length_scale):
    """Evaluate local periodic kernel."""
    kernel = local_periodic_tf(periodic_length_scale, period, 
        amplitude, local_length_scale)
    kernel_matrix = kernel.matrix(xa, xb)
    with tf.Session() as sess:
        return sess.run(kernel_matrix)

The local periodic kernel is vizualized in the next figures. The first figure shows the distance plot with respect to $0$: $k(0, x)$ with only variations of the lengthscale of the exponentiated quadratic.

In [15]:

The following figure shows samples from the local periodic kernel together with a visual representation of its covariance matrix. Only variations of the lengthscale of the exponentiated quadratic $\ell_{eq}$ are shown, the rest of the parameters are fixed to $1$.

Observe that increasing the lengthscale parameter $\ell_{eq}$ increases the periodic covariance over a longer lengthscale and keeps the repetitions close to eachother more consistent.

In [16]:

Combining kernels by addition

Kernels can be combined by adding them together. Adding kernels is an elementwise addition of their corresponding covariance matrices. This means that the covariances of the two added kernels will only have a low value if both of the covariances have a low value. The addition operation can thus be interpreted as an OR operation.

Atmospheric CO₂ kernel

An example of a kernel combined by addition is the kernel we fitted in our previous example of fitting a Gaussian process on atmospheric CO₂ concentrations. This kernel needed to combine different characteristics of the data such as: long term smooth change in CO₂ levels, seasonality, and short to medium term irregularities.

The final kernel was defined as a sum of the exponentiated quadratic kernel, local periodic, and rational quadratic kernel plus observational white noise. The hyperparameters were fitted on the data using a maximum likelihood method.

The prior defined by this kernel with fitted hyperparameters is illustrated in the following figures. These figures will show some samples of the kernel and a visual representation of its covariance over different ranges of input.

In [17]: 
def combined_kernel_tf():
    """Full combined kernel TensorFlow operation."""
    smooth_kernel = exponentiated_quadratic_tf(
        amplitude=94.6903, 
        length_scale=83.0500)
    local_periodic_kernel = local_periodic_tf(
        periodic_length_scale=1.5960, 
        period=0.9996, 
        amplitude=3.1436, 
        local_length_scale=138.6332)
    irregular_kernel = rational_quadratic_tf(
        length_scale=1.7174, 
        scale_mixture=0.0572,
        amplitude=1.3276)  
    return (smooth_kernel + 
            local_periodic_kernel + 
            irregular_kernel)


def combined_kernel(xa, xb):
    """Evaluate full combined kernel."""
    kernel = combined_kernel_tf()
    kernel_matrix = kernel.matrix(xa, xb)
    with tf.Session() as sess:
        return sess.run(kernel_matrix)
In [18]:

References

  1. Gaussian Processes for Machine Learning. Chapter 4: Covariance Functions by Carl Edward Rasmussen and Christopher K. I. Williams.
  2. The Kernel Cookbook by David Duvenaud.
  3. Kernel Design GP Summer School, Sheffield, September 2015. By Nicolas Durrande.
In [19]: 
Python: 3.6.7
numpy: 1.15.4
TensorFlow: 1.12.0
TensorFlow Probability: 0.6.0-dev
matplotlib: 3.0.2
seaborn: 0.9.0

This post at peterroelants.github.io is generated from an Python notebook file. Link to the full IPython notebook file